package cn.itcast.zt.java8.function;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;

import java.util.Collection;

/**
 * 工具类
 * 针对复合条件的复杂判断分支，可以吧判断逻辑放在外面，内部工具类值提供true|false已知情况的逻辑处理
 * create by zhangtian105 on 2022/3/22
 */
public class VUtils {
    /**
     * 单分支
     * 参数为true进行的操作
     * @param flag
     * @return
     */
    public static OneBranchHandler isTrue(boolean flag) {
        return trueHandler -> {
            if (flag) {
                trueHandler.run();
            }
        } ;
    }

    /**
     * 双分支
     * 参数为true或false时，分别进行不同的操作
     * @param flag
     * @return
     */
    public static TwoBranchHandler isTrueOrFalse(boolean flag) {
        return (trueHandler, falseHandler) -> {
            if (flag) {
                trueHandler.run();
            }else {
                falseHandler.run();
            }
        } ;
    }

    /**
     * 创建一个isException方法，方法的返回值为刚才定义的函数式接口-ThrowExceptionFunction
     * ThrowExceptionFunction的接口实现逻辑为当参数flag为true时抛出异常
     * @param flag
     * @return
     */
    public static ThrowExceptionBranchHandler isException(boolean flag) {
        return errorMessage -> {
            if (flag) {
                throw new RuntimeException(errorMessage) ;
            }
        };
    }

    /**
     * 针对参数空情况做不同的处理
     * @param str
     * @return
     */
    public static SingleStrPresentHandler<?> isBlank(String str) {
        return consumer -> {
            if (StrUtil.isNotBlank(str)) {
                consumer.accept(str);
            }
        } ;
    }

    /**
     * 针对参数空情况做不同的处理
     * @param coll
     * @return
     */
    public static SingleCollPresentHandler<?> isEmpty(Collection<?> coll) {
        return consumer -> {
            if (CollUtil.isNotEmpty(coll)) {
                consumer.accept(coll);
            }
        } ;
    }

    /**
     * 参数判断，分别进行不同的操作
     * @param str
     * @return
     */
    public static StrPresentOrElseHandler<?> isBlankOrNoBlank(String str) {
        return (consumer, runnable) -> {
            if (StrUtil.isBlank(str)) {
                runnable.run();
            }else {
                consumer.accept(str);
            }
        } ;
    }

    /**
     * 参数判断，分别进行不同的操作
     * @param coll
     * @return
     */
    public static CollPresentOrElseHandler<?> isEmptyOrNoEmpty(Collection<?> coll) {
        return (consumer, runnable) -> {
            if (CollUtil.isEmpty(coll)) {
                runnable.run();
            }else {
                consumer.accept(coll);
            }
        } ;
    }

    /**
     * 没有入参，通过类型泛型限制响应类型
     * 处理返回处理结果
     * @param clazz
     * @param <R>
     * @return
     */
    public static <R> SupplierPresentHandler<R> isTrue(Class<R> clazz) {
        return supplier -> supplier.get() ;
    }

    /**
     * 有入参出参情况下的分支逻辑
     * T 入参
     * V 响应数据
     * @param flag
     * @param params
     * @return
     */
    public static <T, V> FunctionPresentHandler<T, V> isTrueOrFalse(boolean flag, T params, V v) {
        return (trueFunction, falseFunction) -> {
            if (flag) {
                return trueFunction.apply(params) ;
            }else {
                return falseFunction.apply(params);
            }
        };
    }
}
